package com.itheima.controller;

import com.itheima.pojo.Flux;
import com.itheima.pojo.Result;
import com.itheima.service.FluxService;
import com.itheima.utils.ThreadLocalUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.format.annotation.DateTimeFormat;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;

import java.io.IOException;
import java.io.InputStream;
import java.time.LocalDateTime;
import java.time.temporal.ChronoUnit;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

// 通量接口
@RestController
@RequestMapping("/flux")
public class FluxController {
    @Autowired
    private FluxService fluxService;

    // 上传通量数据接口
    @PostMapping("/uploadData")
    public Result uploadData(@RequestParam("excelFile") MultipartFile file) {
        // 检查上传的文件是否为空
        if (file == null || file.isEmpty()) {
            return Result.error("上传的文件不存在或为空");
        }

        try (InputStream inputStream = file.getInputStream()) {
            // 使用ExcelUtil类读取Excel文件内容并转换为List<Flux>
            List<Flux> fluxList = com.itheima.utils.FluxExcelUtil.readExcel(inputStream);
            // 遍历List<Flux>，将数据存储到数据库中
            for (Flux flux : fluxList) {
                // 检查数据库中是否有与当前flux的timestamp相同的数据

                Flux existingFlux = fluxService.findFluxByTimestamp(flux.getTimestamp());

                if (existingFlux == null) {
                    System.out.println("该条数据不存在并插入:"+flux);

                    // 如果不存在则插入数据
                    fluxService.add(flux);
                }
            }

            return Result.success("文件上传成功，数据已存储");

        } catch (IOException e) {
            return Result.error("文件读取的时候失败: " + e.getMessage());
        } catch (Exception e) {
            return Result.error("数据处理的时候失败: " + e.getMessage());
        }
    }

    // 调整时间到最近的整点或半点
    private LocalDateTime adjustToNearestHalfHour(LocalDateTime time) {
        int minute = time.getMinute();
        if (minute <= 29) {
            // 如果分钟数在0-29之间，调整为当前小时的0分钟
            return time.truncatedTo(ChronoUnit.HOURS);
        } else {
            // 如果分钟数在30-59之间，调整为当前小时的30分钟
            return time.truncatedTo(ChronoUnit.HOURS).plusMinutes(30);
        }
    }
    // 查询某个时间段数据接口
    @GetMapping("/findFluxByTimeRange")
    public Result<List<Flux>> findFluxByTimeRange(
            @RequestParam @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") LocalDateTime startTime,
            @RequestParam @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") LocalDateTime endTime) {
        List<Flux> list = fluxService.findFluxByTimeRange(startTime, endTime);
        return Result.success(list);

        // *处理数据库中无部分或这全部数据的逻辑
        // 调整输入时间，确保分钟数为0或30
//        startTime = adjustToNearestHalfHour(startTime);
//        endTime = adjustToNearestHalfHour(endTime);
//
//        // 查询时间段内的数据
//        List<Flux> list = fluxService.findFluxByTimeRange(startTime, endTime);
//
//        // 生成完整的时间序列（每半小时一个时间点，严格为整点或半点）
//        List<LocalDateTime> fullTimeSeries = new ArrayList<>();
//        LocalDateTime current = startTime;
//        while (current.isBefore(endTime) || current.isEqual(endTime)) {
//            fullTimeSeries.add(current);
//            current = current.plusMinutes(30); // 每半小时一个时间点
//        }
//
//        // 将查询结果转换为Map，便于快速查找
//        Map<LocalDateTime, Flux> dataMap = list.stream()
//                .collect(Collectors.toMap(Flux::getTimestamp, m -> m));
//
//        // 检查数据库中是否已经存在完整的数据
//        boolean isDataComplete = fullTimeSeries.stream().allMatch(dataMap::containsKey);
//
//        List<Flux> filledList;
//
//        if (isDataComplete) {
//            // 如果数据库中已经存在完整的数据，直接返回查询结果
//            filledList = list;
//        } else {
//            // 如果存在缺失数据，按逻辑填补数据
//            filledList = new ArrayList<>();
//            for (LocalDateTime timestamp : fullTimeSeries) {
//                if (dataMap.containsKey(timestamp)) {
//                    // 如果当前时间点有数据，直接使用
//                    filledList.add(dataMap.get(timestamp));
//                } else {
//                    // 如果当前时间点没有数据，尝试从上个月的相同时间点获取数据
//                    LocalDateTime lastMonthTimestamp = timestamp.minusMonths(1);
//                    Flux lastMonthData = fluxService.findFluxByTimestamp(lastMonthTimestamp);
//
//                    if (lastMonthData != null) {
//                        // 使用上个月的数据内容，但保持当前时间点的timestamp
//                        Flux filledData = new Flux();
//                        filledData.setTimestamp(timestamp); // 使用当前时间点的timestamp
//                        filledData.setFc(lastMonthData.getFc());
//                        filledData.setLe(lastMonthData.getLe());
//                        filledData.setH(lastMonthData.getH());
//                        filledData.setFch4(lastMonthData.getFch4());
//                        filledList.add(filledData);
//                    } else {
//                        // 如果上个月也没有数据，生成默认值
//                        Flux defaultData = new Flux();
//                        defaultData.setTimestamp(timestamp);
//                        defaultData.setFc(0.0); // 默认值
//                        defaultData.setLe(0.0);
//                        defaultData.setH(0.0);
//                        defaultData.setFch4(0.0);
//                        filledList.add(defaultData);
//                    }
//                }
//            }
//        }
//
//        // 返回填补后的完整数据列表
//        return Result.success(filledList);

        // *处理数据库中无部分或这全部数据的逻辑
    }

    // 查询数据库中现有数据的最新日期的当天的全部数据
    @GetMapping("/findFluxInLatestDayData")
    public Result<List<Flux>> findFluxInLatestDayData(){
        List<Flux> list = fluxService.findFluxInLatestDayData();
        return Result.success(list);
    }
}